Python 元组

本章我们来学习什么是元组、创建元组、元组索引和切片、元组遍历、修改元组、元组查询、删除元组、元组拆包、选择列表还是元组？元组常用方法等知识，全面掌握Python元组知识。

什么是元组

本节我们来介绍一下另一种数据类型：元组。那什么是元组呢？元组从字面上讲你可以把它理解为，多个元素组成一组，就成了一个元组，前面我们在学习列表的时候，列表也是由多个元素组成的，所以说元组和列表非常的相似，它们都可以存储多个值，不同之处就在于元组是不可变类型的数据，它的元素是不能修改的。所以我们可以对比着列表来学习元组 元组是将这个元素用小括号括起来，注意这里是小号，而列表是中括号，这就是它们创建形式的区别。另外需要注意的是，元组它是不能够修改的，因为它是不可变类型。

创建元组

本节我们来学习创建元组，在创建列表的时候我们介绍了，可以直接对列表进行赋值，也可以使用list函数创建空列表，而元组呢，也是一样的，你可以直接进行赋值。也可以使用tuple函数创建空列表

在Python中，可以使用括号（）来创建元组，元素之间用逗号隔开。例如，下面的代码创建了一个包含3个元素的元组：

t = (1, 2, 3)

如果元组只有一个元素，需要在元素后面加上逗号，否则Python会将其解释为普通的括号。例如，下面的代码创建了一个包含一个元素的元组：

t = (1,)

实例

实例1：创建一个包含不同类型元素的元组

tuple_value = (1,'hello',[1,2,3,4,5],(1,2,3,4,5))

实例2：创建一个空元组

empty_tuple = tuple()

输出结果：

()

实例3：创建一个只包含一个元素的元组

tuple_1 = (1)
tuple_2 = (1,)
print(type(tuple_1))
print(type(tuple_2))

输出结果：

<class 'int'>
<class 'tuple'>

实例4：创建一个只包含一个字符串的元组

tuple_1 = ('andy')
tuple_2 = ('andy',)
print(type(tuple_1))
print(type(tuple_2))

输出结果：

<class 'str'>
<class 'tuple'>

实例5：创建一个不带括号的元组

tuple_1 = 1, 2, 3
print(tuple_1)

输出结果：

(1, 2, 3)

元组索引和切片

本节我们来学习元组索引和切片。在使用元组时，我们经常需要对元组中的元素进行访问或操作，此时就需要用到元组的索引和切片功能。

1. 元组索引

元组中的元素可以通过索引进行访问，索引从 0 开始，依次递增。

语法：

tuple[index]

tuple 表示要访问的元组，index 表示元素的索引。

实例1：通过索引访问元组

tuple_value = (1,'hello',[1,2,3,4,5],(1,2,3,4,5))
print(tuple_value[0])
print(tuple_value[1])
print(tuple_value[2])
print(tuple_value[-1])

输出结果：

1
hello
[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)

2. 元组切片

元组切片是指对元组中的一部分进行访问，返回一个新的元组。

语法：

tuple[start:end:step]

tuple 表示要访问的元组，start 表示起始索引（包含），end 表示结束索引（不包含），step 表示步长（默认为 1）。

实例2：使用切片获取元组内容

tuple_value = (1,'hello',[1,2,3,4,5],(1,2,3,4,5))
print(tuple_value[1:3])     # 第 2 到第 3 个元素
print(tuple_value[:3])      # 第 1 到第 3 个元素
print(tuple_value[2:])      # 第 3 到最后一个元素
print(tuple_value[::2])     # 每隔一个元素访问元组中的元素
print(tuple_value[-1][1:3]) # 获取最后一个元素的第2个到第3个

输出结果：

('hello', [1, 2, 3, 4, 5])
(1, 'hello', [1, 2, 3, 4, 5])
([1, 2, 3, 4, 5], (1, 2, 3, 4, 5))
(1, [1, 2, 3, 4, 5])
(2, 3)

元组遍历

本节我们来学习元组遍历，Python元组遍历是在元组中遍历出所有的元素，和列表相似，可以使用for循环遍历和while循环遍历

语法格式如下：

for 变量 in 元组:
    循环体语句

其中，变量表示循环遍历时每次取出来的元素，可以是任意变量名。元组表示被遍历的元组对象。

实例

实例1：for循环遍历元组

tuple_value = (1,'hello',[1,2,3,4,5],(1,2,3,4,5))
for item in tuple_value:
    print(item)

输出结果为：

1
hello
[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)

实例2：获取元组元素的索引值

tuple1= ('daxiongketang', 'andy', 'python', 'study')
for i in range(len(tuple1)):
    print(i, tuple1[i])

输出结果为：

0 daxiongketang
1 andy
2 python
3 study

在循环体语句中，i表示当前元素的索引值，tup[i]表示当前元素的值。

实例3：使用enumerate()函数获取索引值

enumerate()函数是Python内置函数，用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。使用enumerate()函数可以简化上面range()和len()函数的结合使用，如下所示：

tuple1= ('daxiongketang', 'andy', 'python', 'study')
for i, item in enumerate(tuple1):
    print(i, item)

输出结果为：

0 daxiongketang
1 andy
2 python
3 study

在循环体语句中，i表示当前元素的索引值，item表示当前元素的值。

实例4：在循环中使用切片

切片操作是Python中常用的一种操作，可以通过切片操作来获取元组的部分元素。在遍历元组时，有时候需要遍历元组的一部分元素，可以使用切片操作，如下所示：

tuple1= ('daxiongketang', 'andy', 'python', 'study')
for item in tuple1[:2]:
    print(item)

输出结果为：

daxiongketang
andy

在循环体语句中，tup[:2]表示获取元组的前两个元素。

作业

作业一：已知元组tuple1 = (1, 2, 3, 4, 5)，请使用元组遍历输出该元组中的所有元素。

作业二：已知元组tuple1= ('daxiongketang', 'andy', 'python', 'study')，请使用元组遍历输出该元组中的所有元素及其对应的索引值。

作业三：元组tuple1= ('daxiongketang', 'andy', 'python', 'study')，请使用元组遍历输出该元组中的第二个和第三个元素。

作业四：元组 tuple1 = (1, 2, 3, 4, 5)，请使用元组遍历输出该元组中每个元素的平方值。

作业五：元组tuple1 = (1, 'apple', 3.14, True)，请使用元组遍历输出该元组中的每个元素及其对应的类型。

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

修改元组

本节我们来学习修改元组，对于元组呢，因为它是不可变类型，一旦创建，它们的值不能被更改。但是，在某些情况下，我们可能需要修改元组的值。修改元组有两种方法：使用列表和拼接元组。我们将逐一介绍这两种方法。

1. 使用列表

第一种方法是将元组转换为列表，修改列表，然后将列表转换回元组。

实例1：使用列表转元组的方式

tuple1 = (1, 2, 3)
list1 = list(tuple1)  # 将元组转换为列表
list1[1] = 4          # 修改列表
tuple2 = tuple(list1) # 将列表转换回元组
print(tuple2) 

输出结果：

(1, 4, 3)

2. 拼接元组

第二种方法是使用拼接元组的方式来修改元组。

语法：

tuple[:n] + (val,) + tuple[n+1:]

参数：

• tuple：元组
• n：要修改的元素的索引位置
• val：要插入的新元素

返回值：元组

实例2：用拼接的方式修改元组

tuple1 = (1, 2, 3)
tuple2 = tuple1[:1] + (4,) + tuple1[2:]
print(tuple2) 

输出结果：

(1, 4, 3)

元组查询

本节我们来学习元组查询，元组查询是元组中常用的操作之一，包括in、not in、count、index等方法。

1. in方法

in方法用于检查元组中是否包含某个元素，如果包含，则返回True，否则返回False。

语法如下：

元素 in 元组

其中，元素为要查询的元素，元组为被查询的元组。

实例

实例1：判断元素是否在元组中

tuple1 = ('daxiongketang', 'andy', 'Python', 'xiaoxiong')
print('andy' in tuple1)
print('xiong' in tuple1)

输出结果：

True
False

2. not in方法

not in方法与in方法相反，用于检查元组中是否不包含某个元素，如果不包含，则返回True，否则返回False。

语法如下：

元素 not in 元组

其中，元素为要查询的元素，元组为被查询的元组。

实例2：判断元素是否不在元组中

tuple1 = ('daxiongketang', 'andy', 'Python', 'xiaoxiong')
print('andy' not in tuple1)
print('xiong' not in tuple1)

输出结果：

False
True

3. count方法

count方法用于统计元组中某个元素出现的次数。

语法如下：

元组.count(元素)

其中，元素为要查询的元素，元组为被查询的元组。

实例3：统计元组中元素出现的次数

tuple1 = ('daxiongketang', 'andy', 'Python', 'xiaoxiong', 'Python', 'Python')
print(tuple1.count('Python')) 
print(tuple1.count('xiong')) 

输出结果：

3
0

4. index方法

index方法用于返回元组中某个元素第一次出现的索引位置。

语法如下：

元组.index(元素)

其中，元素为要查询的元素，元组为被查询的元组。如果元素不存在于元组中，则会抛出ValueError异常。

实例：查找元组元素第一次出现的位置

tuple1 = ('daxiongketang', 'andy', 'Python', 'xiaoxiong', 'Python', 'Python')
print(tuple1.index('Python'))
print(tuple1.index('xiong'))

输出结果：

2
ValueError: tuple.index(x): x not in tuple

作业

作业一：用户输入内容，判断元素是否在元组中，如果在，输出该元素的位置；如果不在，输出不存在。

作业二：统计元组中某个元素出现的次数，如果为0，输出不存在。

作业三：查找元素最后一次出现的位置，如果不存在，输出不存在。

tuple1 = ('daxiongketang', 'andy', 'Python', 'xiaoxiong', 'Python', 'Python')

获得作业答案请联系本笔记的配套视频：Python零基础入门动画课【全集】

删除元组

本节我们来学习删除元组，如果你想要删除一个元组，就需要使用Python提供的删除元组的方法：del方法

del是Python的内置函数，用于删除整个元组

语法如下：

del tuple_name

其中，del是Python内置函数，用于删除对象。你只需要指定要删除的元组名称即可。

实例

实例1：使用del删除元组

tuple1 = ('daxiongketang', 'andy', 'Python')
print(tuple1)
del tuple1
print(tuple1)

输出结果：

('daxiongketang', 'andy', 'Python')
NameError: name 'tuple1' is not defined. Did you mean: 'tuple'?

运行上述代码，你会发现程序报错了。这是因为我们在删除元组后又尝试打印元组，而删除后的元组已经不存在了，所以报错了

元组拆包

本节让我们来学习元组的拆包，元组拆包是Python中一种常见的技巧，所谓的拆包就是将元组内部的每个元素。按照对应的位置，一一的赋值给不同的变量，我们来看一下动画演示，这里有元组中的4个元素，在前面我们使用变量food_list，来接收这个元组，但是现在呢，我们想使用元组的拆包方式，那么我们就定义4个变量，它们之间用逗号来分割，然后用这个变量来替换原来的food_list

这4个变量的值是元组中的元素依次分配的，这个过程就叫做元组的拆包

语法

variable1, variable2, ... = tuple

其中，variable1、variable2等为要拆包的变量名，tuple为要拆包的元组名。需要注意的是，被拆包的元组中的元素数量必须与变量数量相等，否则会抛出ValueError异常。

实例

实例1：来演示元组拆包的使用

info = ('Andy','man',18)
name, gender, age = ('Andy','man',18)
print(name)
print(gender)
print(age)

输出结果：

Andy
man
18

实例2：忽略某个元素，可以使用下划线作为占位符

info = ('daxionketang','teacher','Andy','man',18)
_,_,name,gender,age = info
print(name)
print(gender)
print(age)

输出结果：

Andy
man
18

在上面的例子中，我们使用下划线占位符忽略了元组中的第1个和第2个元素，然后将其他元素拆包成独立的变量。最后输出这些变量的值。

实例3：元组元素较多，只拆部分

当元素较多的时候，如果我们使用很多的占位符也不是很方便,这个时候我们应该怎么做呢？我们先来举个例子，range(10)这里有10个元素，如果我现在只想获取前两个和后两个，而中间的不要，这里的a b表示前两个，c d表示后两个，而中间的*rest则表示中间的所有内容，rest名字可自己定义为其他的名称

a,b,*rest,c,d=range(10)
print(a)
print(b)
print(rest)

输出结果：

0
1
[2, 3, 4, 5, 6, 7]

实例4：快速交换

快速交换，比方说我现在有一个变量number1=10，number2=5，现在我想让number1和number2交换值，我们通常会使用一个中间变量，它作为一个中间值，这种方式没有问题，但是它不够Pythonic。

num1 = 10
num2 = 5
tmp = num1
num1 = num2
num2 = tmp
print(num1)
print(num2)

输出结果：

5
10

下面我们使用一个Pythonic的方式

num1 ,num2 = num2, num1
print(num1)
print(num2)

输出结果：

5
10

注意事项

在使用元组拆包时，需要注意以下几个问题：

1. 元组中的元素数量必须与变量数量相等，否则会抛出ValueError异常。
2. 如果不希望使用某个变量，可以使用下划线作为占位符。

选择列表还是元组？

我们已经学习完了列表和元组，并且知道列表和元组，他们都可以存储多个元素。那么我们最终是选择列表呢？还是选择元组呢？这个问题取决于你的使用场景。

我们知道列表它是可变类型，所以对它进行增删改查，等一些相应的操作，如果你要存储的数据是一些可变的数据，比如说像这里的播放量统计，弹幕统计，评论统计等等，这些可变内容你就需要使用列表。

那么元组呢，元组他是不可变类型，所以你要存储的数据是不可变的，哪些数据是不可变的呢？比如说，春夏秋冬四季，一年四季春夏秋冬它是不可变的，这个时候你就可以使用元组，此外呢，一年12个月，这些永远是不会改变的，这种情况下你就可以使用元组 。

这时候有的小伙伴可能就会问了 你这里的1~12月，我用列表依然可以存储啊，的确是这样的，那么接下来我们再从另两个角度再分析一下，一个是存储的空间，一个是运行的效率。

1.对比列表和元组的存储空间

无论是列表还是元组，它都有一个方法叫做_sizeof_，通过这个方法我们可以查看一下，这个变量所占用的内存空间

实例1：对比列表和元组的存储空间

l = [1,2,3,4,5]
print(l.__sizeof__())
t = (1,2,3,4,5)
print(t.__sizeof__())

输出结果：

104
64

从这个例子中我们就可以看到，列表所占用的内存空间要比元组大，就是因为列表它是动态的，所以它需要存储指针来指向对应的元素 另外由于列表可变，所以需要额外存储已经分配的长度大小，这样才能够实时追踪到列表空间的使用情况。对于元组情况就不同了，元素不可变，所以存储的空间是固定的。 2.运行效率 在前面我们使用了一个time函数，然后用结束时间减去开始时间，最后计算出它的运行时间。下面我们使用一个更加简单的模块，叫做timeit。

实例2：对比列表和元组的运行效率

print(timeit('l = [1,2,3,4,5]',number=100000000))
print(timeit('t = (1,2,3,4,5)',number=100000000))

输出结果：

4.127275182050653
0.9464873940451071

看到上面结果，所以说元组的运行效率要远远高于列表的运行效率

下面我们来总结一下列表和元组：

• 列表它是动态的，长度是可变的，可以随意的增加，删减或者是改变元素，而列表的存储空间要略大于元组，于性能要略逊于元组。
• 元组它是静态的，长度大小是固定的，是不可以对元素进行增加，删减或者是改变，元组相对于列表是更加轻量级的，性能更优的 。
• 在选择使用列表和元组这个问题上，我们有一个原则，就是能用元组的，就尽量用元组，不能用元组的，你在用列表。

元组常用方法

本节我们来介绍一下元组的常用方法汇总，下面按照使用程度的高低给大家做了一个元组常用方法的表格，并且每个方法带超链接，点击方法名字，都有对各个方法的详细介绍。

序号	常用方法	描述
1	count(x)	统计元组中x出现的次数
2	index(x)	返回元组中x第一次出现的下标
3	len()	返回元组中元素的个数
4	max()	返回元组中最大的元素
5	min()	返回元组中最小的元素
6	sorted()	返回一个排序后的元组
7	any()	判断元组中是否有任意一个元素为True
8	all()	判断元组中所有元素是否都为True
9	sum()	对元组中所有元素进行求和
10	tuple(iterable)	将可迭代对象转换为元组
11	slicing	切片操作，获取元组的子集
12	unpacking	将元组中的元素解包为多个变量
13	zip()	将多个元组合并为一个元组
14	enumerate()	返回元组中元素的下标和值
15	reversed()	返回一个反转后的元组
16	hash()	返回元组的哈希值
17	join()	将元组中的字符串连接成一个字符串
18	format()	格式化元组中的元素输出